#include "W25Q64_Demo.h"
#include "Storage_Adapter.h"
#include "bsp_dht11.h"
#include <stdio.h>

/**
  * @brief  W25Q64存储系统演示程序
  * @param  None
  * @retval None
  */
void W25Q64_Demo_Main(void)
{
    Storage_Status_TypeDef status;
    DHT11_Data_TypeDef dht11_data;
    DHT11_Storage_Data_TypeDef storage_data;
    uint32_t timestamp = 0;
    
    printf("\r\n========== W25Q64存储系统演示程序 ==========\r\n");
    
    /* 1. 初始化存储系统 */
    printf("\r\n1. 初始化W25Q64存储系统...\r\n");
    status = Storage_Init();
    if(status == STORAGE_SUCCESS)
    {
        printf("W25Q64存储系统初始化成功!\r\n");
    }
    else
    {
        printf("W25Q64存储系统初始化失败! 错误码: %d\r\n", status);
        return;
    }
    
    /* 2. 测试存储系统 */
    printf("\r\n2. 测试W25Q64存储系统...\r\n");
    status = Storage_Test();
    if(status == STORAGE_SUCCESS)
    {
        printf("W25Q64存储系统测试通过!\r\n");
    }
    else
    {
        printf("W25Q64存储系统测试失败! 错误码: %d\r\n", status);
    }
    
    /* 3. 打印存储系统信息 */
    printf("\r\n3. 存储系统信息:\r\n");
    DHT11_Storage_PrintInfo();
    
    /* 4. 检查现有数据 */
    printf("\r\n4. 检查现有数据...\r\n");
    if(DHT11_Storage_HasValidData())
    {
        printf("发现现有数据，总记录数: %d\r\n", DHT11_Storage_GetRecordCount());
        DHT11_Storage_PrintLatestData();
    }
    else
    {
        printf("暂无现有数据\r\n");
    }
    
    /* 5. 演示数据存储 */
    printf("\r\n5. 演示DHT11数据存储...\r\n");
    
    // 模拟DHT11数据
    dht11_data.humi_int = 65;
    dht11_data.humi_deci = 3;
    dht11_data.temp_int = 25;
    dht11_data.temp_deci = 8;
    dht11_data.check_sum = dht11_data.humi_int + dht11_data.humi_deci + 
                          dht11_data.temp_int + dht11_data.temp_deci;
    
    // 存储几条测试数据
    for(int i = 0; i < 5; i++)
    {
        timestamp = 1000 + i * 60;  // 模拟每分钟一条数据
        
        // 稍微变化数据
        dht11_data.temp_int = 25 + (i % 3);
        dht11_data.humi_int = 65 - (i % 5);
        dht11_data.check_sum = dht11_data.humi_int + dht11_data.humi_deci + 
                              dht11_data.temp_int + dht11_data.temp_deci;
        
        status = DHT11_Storage_SaveData(&dht11_data, timestamp);
        if(status == STORAGE_SUCCESS)
        {
            printf("第%d条数据存储成功: 温度=%d.%d℃, 湿度=%d.%d%%RH, 时间戳=%ds\r\n",
                   i+1, dht11_data.temp_int, dht11_data.temp_deci,
                   dht11_data.humi_int, dht11_data.humi_deci, timestamp);
        }
        else
        {
            printf("第%d条数据存储失败! 错误码: %d\r\n", i+1, status);
        }
    }
    
    /* 6. 读取并显示最新数据 */
    printf("\r\n6. 读取最新数据:\r\n");
    DHT11_Storage_PrintLatestData();
    
    /* 7. 显示所有数据 (仅W25Q64支持) */
    printf("\r\n7. 显示所有存储的数据:\r\n");
    DHT11_Storage_PrintAllData();
    
    /* 8. 演示按索引读取数据 */
    printf("\r\n8. 演示按索引读取数据:\r\n");
    uint32_t record_count = DHT11_Storage_GetRecordCount();
    for(uint32_t i = 0; i < record_count && i < 3; i++)  // 只显示前3条
    {
        status = DHT11_Storage_ReadDataByIndex(i, &storage_data);
        if(status == STORAGE_SUCCESS)
        {
            printf("索引%d: 时间戳=%ds, 温度=%d.%d℃, 湿度=%d.%d%%RH\r\n",
                   i, storage_data.timestamp, storage_data.temp_int, storage_data.temp_deci,
                   storage_data.humi_int, storage_data.humi_deci);
        }
        else
        {
            printf("索引%d: 读取失败，错误码: %d\r\n", i, status);
        }
    }
    
    printf("\r\n========== W25Q64存储系统演示完成 ==========\r\n");
}

/**
  * @brief  W25Q64存储模式切换演示
  * @param  None
  * @retval None
  */
void W25Q64_Demo_StorageMode(void)
{
    Storage_Status_TypeDef status;
    
    printf("\r\n========== W25Q64存储模式演示 ==========\r\n");
    
    /* 显示当前模式 */
    uint8_t current_mode = DHT11_Storage_GetMode();
    printf("当前存储模式: %s\r\n", 
           (current_mode == 0) ? "覆盖模式" : "环形缓冲模式");
    
    /* 切换到环形缓冲模式 */
    printf("\r\n切换到环形缓冲模式...\r\n");
    status = DHT11_Storage_SetMode(1);  // 1 = 环形缓冲模式
    if(status == STORAGE_SUCCESS)
    {
        printf("存储模式切换成功!\r\n");
    }
    else
    {
        printf("存储模式切换失败! 错误码: %d\r\n", status);
    }
    
    /* 在环形缓冲模式下存储更多数据 */
    printf("\r\n在环形缓冲模式下存储10条数据...\r\n");
    DHT11_Data_TypeDef dht11_data;
    for(int i = 0; i < 10; i++)
    {
        dht11_data.temp_int = 20 + (i % 10);
        dht11_data.temp_deci = i % 10;
        dht11_data.humi_int = 50 + (i % 20);
        dht11_data.humi_deci = (i * 2) % 10;
        dht11_data.check_sum = dht11_data.humi_int + dht11_data.humi_deci + 
                              dht11_data.temp_int + dht11_data.temp_deci;
        
        uint32_t timestamp = 2000 + i * 30;  // 每30秒一条数据
        
        status = DHT11_Storage_SaveData(&dht11_data, timestamp);
        if(status == STORAGE_SUCCESS)
        {
            printf("数据%d存储成功\r\n", i+1);
        }
    }
    
    /* 显示存储结果 */
    printf("\r\n存储完成，当前状态:\r\n");
    printf("总记录数: %d\r\n", DHT11_Storage_GetRecordCount());
    DHT11_Storage_PrintLatestData();
    
    printf("\r\n========== 存储模式演示完成 ==========\r\n");
}

/**
  * @brief  W25Q64格式化演示
  * @param  None
  * @retval None
  */
void W25Q64_Demo_Format(void)
{
    Storage_Status_TypeDef status;
    char confirm;
    
    printf("\r\n========== W25Q64格式化演示 ==========\r\n");
    
    /* 显示格式化前的状态 */
    printf("格式化前的状态:\r\n");
    printf("总记录数: %d\r\n", DHT11_Storage_GetRecordCount());
    DHT11_Storage_PrintInfo();
    
    /* 确认格式化操作 */
    printf("\r\n警告: 格式化将清除所有数据!\r\n");
    printf("请输入 'Y' 确认格式化，其他键取消: ");
    
    // 注意：这里需要根据你的串口输入实现来调整
    // scanf("%c", &confirm);  // 如果支持scanf
    confirm = 'Y';  // 演示用，直接设置为确认
    
    if(confirm == 'Y' || confirm == 'y')
    {
        printf("Y\r\n开始格式化...\r\n");
        
        status = DHT11_Storage_Format();
        if(status == STORAGE_SUCCESS)
        {
            printf("格式化完成!\r\n");
        }
        else
        {
            printf("格式化失败! 错误码: %d\r\n", status);
        }
        
        /* 显示格式化后的状态 */
        printf("\r\n格式化后的状态:\r\n");
        printf("总记录数: %d\r\n", DHT11_Storage_GetRecordCount());
        DHT11_Storage_PrintInfo();
    }
    else
    {
        printf("格式化操作已取消\r\n");
    }
    
    printf("\r\n========== 格式化演示完成 ==========\r\n");
}

/**
  * @brief  W25Q64性能测试
  * @param  None
  * @retval None
  */
void W25Q64_Demo_Performance(void)
{
    Storage_Status_TypeDef status;
    DHT11_Data_TypeDef dht11_data;
    uint32_t start_time, end_time;
    const uint32_t test_count = 100;
    
    printf("\r\n========== W25Q64性能测试 ==========\r\n");
    
    /* 准备测试数据 */
    dht11_data.temp_int = 25;
    dht11_data.temp_deci = 5;
    dht11_data.humi_int = 60;
    dht11_data.humi_deci = 2;
    dht11_data.check_sum = dht11_data.humi_int + dht11_data.humi_deci + 
                          dht11_data.temp_int + dht11_data.temp_deci;
    
    /* 设置为环形缓冲模式以支持多条记录 */
    DHT11_Storage_SetMode(1);
    
    printf("测试写入%d条记录的性能...\r\n", test_count);
    
    // 注意：这里需要根据你的系统时钟实现来获取时间
    // start_time = get_system_time_ms();  // 获取系统时间(毫秒)
    start_time = 0;  // 演示用
    
    /* 写入测试 */
    for(uint32_t i = 0; i < test_count; i++)
    {
        status = DHT11_Storage_SaveData(&dht11_data, i);
        if(status != STORAGE_SUCCESS)
        {
            printf("写入失败在第%d条记录，错误码: %d\r\n", i+1, status);
            break;
        }
        
        // 每10条显示一次进度
        if((i + 1) % 10 == 0)
        {
            printf("已写入 %d/%d 条记录\r\n", i+1, test_count);
        }
    }
    
    // end_time = get_system_time_ms();  // 获取系统时间(毫秒)
    end_time = 1000;  // 演示用，假设耗时1秒
    
    printf("\r\n写入性能测试结果:\r\n");
    printf("写入记录数: %d\r\n", test_count);
    printf("耗时: %d毫秒\r\n", end_time - start_time);
    printf("平均每条记录耗时: %.2f毫秒\r\n", (float)(end_time - start_time) / test_count);
    
    /* 读取测试 */
    printf("\r\n测试读取性能...\r\n");
    DHT11_Storage_Data_TypeDef read_data;
    
    start_time = 0;  // 演示用
    
    for(uint32_t i = 0; i < test_count && i < DHT11_Storage_GetRecordCount(); i++)
    {
        status = DHT11_Storage_ReadDataByIndex(i, &read_data);
        if(status != STORAGE_SUCCESS)
        {
            printf("读取失败在第%d条记录，错误码: %d\r\n", i+1, status);
            break;
        }
    }
    
    end_time = 500;  // 演示用，假设耗时0.5秒
    
    printf("\r\n读取性能测试结果:\r\n");
    printf("读取记录数: %d\r\n", test_count);
    printf("耗时: %d毫秒\r\n", end_time - start_time);
    printf("平均每条记录耗时: %.2f毫秒\r\n", (float)(end_time - start_time) / test_count);
    
    printf("\r\n========== 性能测试完成 ==========\r\n");
}